package Threading2;

import java.security.Signature;

// 单例模式
// 饿汉模式
class Singleton {
    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }

    // 禁止外部 new 实例
    private Singleton() {}
}


// 通过懒汉模式实现一个单例模式

class SingletonLazy {
    volatile private static SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }

    // 要记得将构造方法设置成private 的，此时才能算是单例模式

    private SingletonLazy () {}
}
public class ThreadDemo10 {
    public static void main(String[] args) {
        // 通过懒汉模式来创建一个单例模式的实例
        SingletonLazy s1 = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
        // 只能允许创建一个实例，后续再去拿到这个实例，上述逻辑会判定这个实例不为空，此时就不会再创建新的实例了
    }

    public static void main1(String[] args) {
        // 此时 s1 和 s2 是同一个 Singleton 对象
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

        // Singleton singleton = new Singleton();  // 上边的类的构造方法已经是 private 的了，此时就不能new新的对象了
    }


    // 消息队列服务器的作用：解耦合，削峰填谷
    //
}
